/**
 * Copyright (c) 2011 eelpo.com
 * All rights reserved.
 */
package com.eelpo.common.util;

import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.regex.Pattern;

/**
 * 字符串处理工具类
 * 
 * @author <a href="mailto:Brian@eelpo.com">汪洪州</a>
 * @since 1.0
 */
public class StringUtils {

	/**
	 * 空字符
	 */
	public static final String EMPTY = "";

	/**
	 * 将集合中的字符串以分隔符合并
	 * 
	 * @param str
	 *            要合并的集合
	 * @param separator
	 *            分隔符
	 * @return 返回合并后的字符串
	 */
	public static String join(Collection<String> str, CharSequence separator) {
		return join(str, separator, EMPTY);
	}

	/**
	 * 将字符串数组中的字符串以分隔符合并
	 * 
	 * @param str
	 *            字符串数组
	 * @param separator
	 *            分隔符
	 * @return 返回合并后的字符串
	 */
	public static String join(String[] str, CharSequence separator) {
		return join(str, separator, EMPTY);
	}

	/**
	 * 将集合中的字符串以分隔符合并,并在前后加上指定字符
	 * 
	 * @param str
	 *            字符串数组
	 * @param separator
	 *            分隔符
	 * @param bothSides
	 *            前后指定字符
	 * @return 返回合并后的字符串
	 */
	public static String join(String[] str, CharSequence separator, CharSequence bothSides) {
		return join(Arrays.asList(str), separator, bothSides);
	}

	/**
	 * 将字符串数组中的字符串以分隔符合并,并在前后加上指定字符
	 * 
	 * @param str
	 *            要合并的集合
	 * @param separator
	 *            分隔符
	 * @param bothSides
	 *            前后指定字符
	 * @return 返回合并后的字符串
	 */
	public static String join(Collection<String> str, CharSequence separator, CharSequence bothSides) {
		StringBuilder join = new StringBuilder();
		Iterator<String> iterator = str.iterator();

		join.append(bothSides);
		while (iterator.hasNext()) {
			join.append(iterator.next());

			if (iterator.hasNext()) {
				join.append(separator);
			}
		}
		join.append(bothSides);
		return join.toString();
	}

	/**
	 * 将字符串重复指定次数后合并
	 * 
	 * @param str
	 *            需要重复的字符串
	 * @param count
	 *            重复次数
	 * @param separator
	 *            分隔符
	 * @return 返回合并后的字符串
	 */
	public static String join(String str, int count, CharSequence separator) {
		return join(str, count, separator, EMPTY);
	}

	/**
	 * 将字符串重复指定次数后合并,并在前后加上指定字符
	 * 
	 * @param str
	 *            需要重复的字符串
	 * @param count
	 *            重复次数
	 * @param separator
	 *            分隔符
	 * @param bothSides
	 *            前后指定字符
	 * @return 返回合并后的字符串
	 */
	public static String join(String str, int count, CharSequence separator, CharSequence bothSides) {

		StringBuilder join = new StringBuilder();

		join.append(bothSides);
		for (int i = 1; i <= count; i++) {
			join.append(str);

			if (i != count) {
				join.append(separator);
			}
		}
		join.append(bothSides);

		return join.toString();
	}

	/**
	 * 判断一个字符串中是否包含另一字符串
	 * 
	 * @param source
	 *            要判断的字符串
	 * @param search
	 *            要查找的字符串
	 * @return 返回true和false,true表示包含
	 */
	public static boolean isContains(String source, String search) {
		return source.indexOf(search) != -1;
	}

	/**
	 * 根据正则表达式匹配输入字符串
	 * 
	 * @param regex
	 *            正则表达式
	 * @param input
	 *            输入的字符串
	 * @return 返回true和false,true表示匹配
	 */
	public static boolean matches(String regex, String input) {
		return Pattern.matches(regex, input);
	}

	/**
	 * 判断一个字符串是否为正整数
	 * 
	 * @param input
	 *            要判断的字符串
	 * @return 返回true和false,true表示该字符串为正整数
	 */
	public static boolean isPositiveInteger(String input) {
		return matches("^\\d*$", input);
	}

	/**
	 * 判断一个字符串是否为整数
	 * 
	 * @param input
	 *            要判断的字符串
	 * @return 返回true和false,true表示该字符串为整数
	 */
	public static boolean isInteger(String input) {
		return matches("^[+-]?\\d+$", input);
	}

	/**
	 * 判断一个字符串是否为浮点数
	 * 
	 * @param input
	 *            要判断的字符串
	 * @return 返回true和false,true表示该字符串为浮点数
	 */
	public static boolean isFloat(String input) {
		return matches("^[+-]?(\\d+|(\\d+.\\d+))$", input);
	}
}
